COMMENT ⊗   VALID 00012 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	.SBTTL  Floating point routines
C00004 00003	STRING TO FLOATING POINT NUMBER ROUTINE - "RELSCN".
C00007 00004		[CONTINUATION OF "RELSCN"]
C00010 00005		[CONTINUATION OF "RELSCN"]
C00012 00006	ROUTINES TO SET AND RESTORE OUTPUT FORMAT - "FORMAT"&"RSTFOR"
C00014 00007	FLOATING POINT NUMBER TO "F" FORMAT STRING ROUTINE - "CVF"
C00017 00008	FLOATING POINT NUMBER TO "E" FORMAT STRING ROUTINE - "CVE"
C00020 00009		[CONTINUATION OF "CVE"]
C00021 00010	FLOATING POINT NUMBER TO "E" OR "F" FORMAT STRING  - "CVG"
C00023 00011		PRINTING ROUTINE USED BY "CVF" & "CVE"
C00026 00012	LOCAL STORAGE AREA
C00031 ENDMK
C⊗;
.SBTTL  Floating point routines

;The following pages contain floating point input-output routines.
;Coded by BES 9/74.


.IFNZ FLOAT
;STRING TO FLOATING POINT NUMBER ROUTINE - "RELSCN".

;THE FLOATING POINT NUMBER MUST BE OF THE FORM SIII.DDDESXX WHERE S IS
;THE SIGN OF THE NUMBER, III IS THE INTEGER FIELD,  DDD IS THE DECIMAL
;FIELD,  AND SXX  IS THE EXPONENT  AND ITS SIGN.   THE LENGTH OF  EACH
;FIELD IS VARIABLE  BUT ONLY THE FIRST 8 DIGITS  ARE USED IN COMPUTING
;THE F.P.   NUMBER.  EMPTY FIELDS ARE PERMITTED AND ALL LEADING SPACES
;AND ZEROS ARE IGNORED.  THE LOCATION OF THE FIRST  BYTE OF THE STRING
;MUST  BE LOADED INTO  R0 BEFORE  CALLING "RELSCN".   AFTER EXECUTION,
;THIS ROUTINE LEAVES THE F.P. NUMBER IN REGISTER AC0 AND R0 POINTS  TO
;THE BYTE FOLLOWING THE LAST DIGIT.  R1 CONTAINS AN ERROR CODE.  IF NO
;NUMBER WAS FOUND, R1 IS  -1 ELSE R1 IS 0.  "RELSCN" IS  CALLED IN THE
;"SIMPLE STYLE".

;REGISTERS USED:
;
;	R0,R1,AC0 PASS ARGUMENTS
;	NO OTHER REGISTERS AFFECTED

.STITLE FLOATING POINT TO/FROM STRING CONVERSION ROUTINES

;"DIGIT" CHECKS FOR ASC DIGIT AND CONVERTS TO INTEGER IF IT IS

.MACRO DIGIT NOTDIG
	CMP	R4,#60		;COMPARE TO ASC ZERO
	BLT	NOTDIG		;SKIP IF OUT OF RANGE
	CMP	R4,#71		;COMPARE TO ASC 9
	BGT	NOTDIG		;SKIP IF OUT OF RANGE
	BIC	#60,R4		;MASK OUT ASC BASE
.ENDM

;"CKSIGN" CHECKS FOR A - OR + CHARACTER AND SETS SIGN APPROPRIATELY

.MACRO CKSIGN ISSIGN,NTSIGN,SIGN
	CMP	#53,R4		;IGNOR "+" CHARACTER
	BEQ	ISSIGN
	CMP	#55,R4		;CHECK IF ITS A "-" CHAR.
	BNE	NTSIGN		;EXIT IF ITS NOT
	INC	SIGN		;ELSE SET SIGN NON-ZERO
	BR 	ISSIGN
.ENDM

;START OF "RELSCN"

.EVEN
RELSCN:	MOV	R2,-(SP)	;SAVE REGISTER
      	MOV	R3,-(SP)	;SAVE REGISTER
	MOV	R4,-(SP)
      	CLR	R2 		;RESET DIGIT COUNT
	MOV	#1,R3		;SET DECIMAL POINT FLAG
	[CONTINUATION OF "RELSCN"]

	MOV	#-1,R1		;INDICATE NO DIGITS ENCOUNTERED
 	CLRF	AC0		;CLEAR THE NUMBER ACCUM
	CLR	MSIGN		;ASSUME MANTISSA POSITIVE

;PICK UP A CHARACTER AND CHECK FOR SIGN

PICK:	MOVB	(R0)+,R4	;PICK UP A CHARACTER
	TST	R1		;CHECK IF DIGIT ENCOUNTERED
	BEQ	CHKDG		;SKIP IF TRUE
	CKSIGN	PICK,CHKDG,MSIGN	;CHECK FOR + OR - SIGN

;CHECK IF CHARARCTER IS A DIGIT

CHKDG:	DIGIT	CHKDP		;SKIP TO CHKDP IF NOT A DIGIT
	MULF	TEN,AC0		;MULT DIGIT SUM BY 10
	ASH	#2,R4		;MULTIPLY INDEX BY 4
	ADDF	DGLST(R4),AC0	;ADD THE F.P. TO ACCUM
	CLR     R1    		;INDICATE DIGIT ENCOUNTERED
	SUB     #4,R2		;DECREMENT DIGIT COUNT
	JMP	PICK		;GO GET ANOTHER CHARACTER

;CHECK IF THE CHARACTER IS A DECIMAL POINT

CHKDP:	CMP	#56,R4		;COMPARE CHARACTER TO DECIMAL PT
	BNE	RNORM		;SKIP IF NOT D.P.
      	TST	R3		;CHECK IF DECIMAL POINT ALREADY SET
	BEQ	RNORM		;IF RESET THIS MUST BE A THE END OF THE MANT.
	CLR	R2		;START COUNTING FRACTIONAL DIGITS
	CLR	R3		;INDICATE D.P. SET
	CLR	R1		;INDICATE DIGIT ENCOUNTERED
	JMP	PICK		;GO GET ANOTHER CHARACTER

;CORRECT NUMBER FOR POWER OF TEN IF DIGITS FOUND

RNORM:	TST	R1		;CHECK IF DIGITS FOUND
	BNE	CHKEX		;SKIP IF NONE
	TST	R3		;CHECK IF DECIMAL POINT SET
	BNE	CHKEX		;DONT NORMALIZE IF NO D.P.
    	MULF	TENLST(R2),AC0	;CORRECT DECIMAL POINT

;CHECK IF E SIGN ENCOUNTERED

CHKEX:	CMP	#105,R4		;COMPARE TO E CHARACTER
	BNE	CHKDN		;SKIP IF NOT E
	TST	R1   		;CHECK IF NO DIGITS BEFORE E
	[CONTINUATION OF "RELSCN"]

	BEQ	EXCN
	LDF	TENLST,AC0	;SET AC0=1 IF EXPONENT BUT NO DIGITS
	CLR	R1		;INDICATE DIGITS ENCOUNTERED
EXCN:	CLR	ESIGN		;ASSUME EXPONENT POSITIVE
	CLR	R3		;CLEAR EXPONENT ACCUMULATOR

	MOVB	(R0)+,R4	;GET NEXT CHARACTER
	CKSIGN	PIC2,DIG2,ESIGN	;CHECK FOR SIGN CHARACTER
PIC2:	MOVB	(R0)+,R4	;SIGN INCOUNTERED, GET NEXT CHAR.
DIG2:	DIGIT	NORM		;EXTRACT DIGIT 
	MUL	#10.,R3		;MULT EXPON REG BY 10.
	ADD	R4,R3		;ADD DIGIT TO EXPONENT REG
	JMP	PIC2		;GO GET ANOTHER CHARACTER

NORM:	TST	ESIGN		;CHECK SIGN OF EXPONENT
	BEQ	.+4
	NEG	R3		;COMPLEMENT EXPONENT IF - SIGN
	ASH	#2,R3		;MULT. INDEX BY 4 FOR F.P. NUMBERS
	MULF	TENLST(R3),AC0	;ADJUST EXPONENT OF NUMBER
	JMP	CDONE		;EXIT ROUTINE

;CHECK IF END OF NUMBER

CHKDN:	TST     R4		;COMPARE CHARACTER TO A NULL CHARACTER
	BEQ	CDONE		;EXIT IF IT IS, THIS IS THE END OF THE STR
	TST	R1		;TEST IF ANY DIGITS YET
	BLT	PICK		;IF NONE, KEEP SCANNING

;NO MORE DIGITS - APPLY CORRECT SIGN TO NUMBER

CDONE:	MOV	(SP)+,R4	;RESTORE REGISTERS
     	MOV	(SP)+,R3
	MOV	(SP)+,R2
	DEC	R0		;POINT TO BREAK CHARACTER
    	TST	MSIGN		;TEST SIGN OF MANTISSA
	BEQ	.+4
	NEGF	AC0		;COMPLEMENT NUMBER IF SIGN NEGATIVE
	RTS	PC		;RETURN
;ROUTINES TO SET AND RESTORE OUTPUT FORMAT - "FORMAT"&"RSTFOR"

;THE TOTAL NUMBER OF CHARACTERS TO BE WRITTEN (WIDTH) SHOULD BE
;LOADED INTO R0 AND THE NUMBER OF DECIMAL DIGITS (DIGITS) SHOULD
;BE LOADED INTO R1 BEFORE CALLING THIS ROUTINE.  IN ALL CASES,
;WIDTH SHOULD BE GREATER THAN OR EQUAL TO DIGIT+2.  "FORMAT" IS
;CALLED BY THE "SIMPLE METHOD".

;REGISTERS USED:
;
;	R0,R1 PASS ARGUMENTS
;	NO OTHER REGISTERS AFFECTED

FORMAT:	MOV	WIDTH,OLDW	;SAVE THE OLD WIDTH
	MOV	DIG,OLDD	;   AND DIG
	SUB	#2,R0		;SUBTRACT SPACES FOR SIGN AND . FROM WIDTH
	MOV	R0,WIDTH	;SAVE WIDTH OF I/O STRING - 2
	MOV	R1,DIG		;SAVE THE NUMBER OF DECI. DIGITS
	CMP	R0,R1		;CHECK TO SEE THAT WIDTH.GE.DIGIT+2
	BGE	NFER		;SKIP IF SPACE ALLOWED, ELSE CORRECT
	OUTSTR	FERM		;TYPE OUT ERROR MESSAGE
	MOV	R1,WIDTH	;SET WIDTH=DIG+2
NFER:	RTS	PC		;RETURN

FERM:	.ASCIZ /
FORMATTING ERROR
/
	.EVEN


;ROUTINE TO RESTORE LAST FORMAT - "RSTFOR"

;THE PREVIOUS FORMAT BECOMES THE CURRENT FORMAT.  THE CURRENT
;FORMAT IS LOST FOREVER.  "RSTFOR" IS CALLED IN THE "SIMPLE 
;METHOD".

;REGISTERS USED:  NONE

RSTFOR:	MOV	OLDW,WIDTH	;RESTORE WIDTH
	MOV	OLDD,DIG	;RESTORE DIG
	RTS	PC		;RETURN
;FLOATING POINT NUMBER TO "F" FORMAT STRING ROUTINE - "CVF"

;"CVF" - THE STRING GENERATED BY THIS ROUTINE IS SIMILAR TO "F" FORMAT
;IN  FORTRAN.  IT  IS ASSUMED  THAT THE NUMBER  TO BE CONVERTED  IS IN
;REGISTER AC0  AND R0  CONTAINS A  POINTER TO  THE FIRST  BYTE OF  THE
;OUTPUT STRING.  THE NUMBER OF  CHARACTERS WRITTEN SHOULD FIRST BE SET
;IN  A CALL  TO "FORMAT", ELSE  THE DEFAULT VALUES  ARE USED.   IF THE
;INTEGER PART  OF  THE  NUMBER EXCEEDS  THE  FORMAT LIMITS  THE  FIRST
;CHARACTER WRITTEN  IS A ">".   AFTER COMPLETION, "CVF"  LEAVES A NULL
;CHARACTER FOLLOWING THE NUMBER STRING.  REGISTER R0 IS LEFT  POINTING
;AT THE NULL CHARACTER.

;REGISTERS USED:
;
;	R0,AC0 PASS ARGUMENTS
;	R1,AC1 GARBAGED

CVF:	MOV	WIDTH,R1	;GET THE TOTAL NUMBER OF CHAR TO BE WRITTEN
	SUB	DIG,R1		;DETERMINE THE MAG. OF THE M.S. DIGIT
	MOV	R1,PT		;NOW HAVE # OF DIGITS BEFORE DECIMAL POINT
	ASH	#2,R1		;X 4, USE AS INDEX INTO F.P. TABLE
	DIVF	TENLST(R1),AC0	;NORMALIZE NUMBER TO BETWEEN 0 AND .99999999
	MOV	WIDTH,R1	;TOTAL # OF DIGITS TO R1
	MOV	R2,-(SP)	;SAVE THE REGISTERS
	MOV	R3,-(SP)
	JSR	PC,PRTF		;TYPE OUT THE DIGITS
	MOVB	#0,(R0)		;PUT A NULL CHARACTER AFTER THE STRING
	MOV	(SP)+,R3	;RESTORE THE REGISTERS
	MOV	(SP)+,R2
	RTS	PC		;RETURN
;FLOATING POINT NUMBER TO "E" FORMAT STRING ROUTINE - "CVE"

;"CVE" - SAME OPERATION AS "CVF" EXCEPT THAT OUTPUT IN FORTRAN "E" FORMAT

CVE:	MOV	R2,-(SP)	;SAVE THE REGISTERS
	MOV 	R3,-(SP)
        CLR     EXPON		;RESET EXPONENT COUNT
	MOV	#1,PT		;SET COUNT TO PRINT 1 NUMBER BEFORE DECIMAL PT
	MOV	WIDTH,R1	;SET COUNT FOR TOTAL NUMBER OF DIGITS TO BE SENT
	SUB	#4,R1		;ADJUST FOR EXPONENT
	TSTF	AC0		;CHECK IF NUMBER IS ZERO
	CFCC			;TRANSFER CONDITIONAL CODES TO CPU
	BEQ	EPRT		;START PRINTING IF NUMBER IS 0.0
     	STF	AC0,NUM		;GET THE NUMBER TO BE CONVERTED
	DEC	EXPON		;ADJUST EXPONENT FOR PRINTING 1 INT. DIGIT
	MOV	NUM,R2		;LOAD THE EXPONENT AND MSB OF THE NUMBER
	BIC	#100000,R2	;CONVERT TO ABSOLUTE VALUE
	SUB	#150,R2		;ADJUST EXPONENT DOWN
	BGE	.+4
	CLR	R2		;LEAVE IT POSITIVE
	MUL	#233,R2		;USE EXPONENT AND MSB AS INDEX INTO TEN TABLE
	CMP	R2,#76.		;COMPARE TO 1.0@38
	BLE	.+6
	MOV	#76.,R2		;IF LARGER, REPLACE BY 1.0@38
      	SUB	#38.,R2		;SHIFT INDEX INTO RANGE OF -38 TO +38
	ADD	R2,EXPON	;ADJUST EXPONENT COUNT
	ASH	#2,R2		;MULT INDEX BY 4 FOR FLOATING POINT NUMBERS
	DIVF	TENLST(R2),AC0	;NORMALIZE NUMBER INTO RANGE 0.0 TO 0.9999
	STF	AC0,AC1		;GET ABSOLUTE VALUE OF NUMBER
	ABSF	AC1
	CMPF	TENLST,AC1	;CHECK IF NUMBER LESS THAN 1.0
	CFCC			;TRANSFER CONDITIONAL CODES TO CPU
	BGT	EPRT		;IF ITS BETWEEN 0.0 AND .99999, GO TO PNTF
	DIVF	TEN,AC0		;ELSE MULT. BY 0.1 AND ADJUST EXPONENT
        INC	EXPON
	[CONTINUATION OF "CVE"]

EPRT:	JSR	PC,PRTF		;GO PRINT MANTISSA
	MOVB	#105,(R0)+	;PUT A "E" CHAR INTO THE STRING
	MOVB	#53,(R0)+	;ASSUME EXPONENT POSITIVE A OUTPUT A "+"
	MOV	EXPON,R3	;TEST SIGN OF EXPONENT
	BGE	XPRT		;SKIP IF POSITIVE
	MOVB	#55,-1(R0)	;REPLACE "+" WITH "-"
	NEG	R3    		;MAKE EXPONENT POSITIVE
XPRT:	CLR	R2		;CLEAR FOR DIVISION
     	DIV	#10.,R2		;SEPARATES TENS AND UNITS DIGIT
	BIS	#60,R2		;CONVERT TO ASC AND PUT IN I/O BUFFER
	MOVB	R2,(R0)+
	BIS	#60,R3
	MOVB	R3,(R0)+
	MOVB	#0,(R0)		;PUT IN A NULL CHARACTER
	MOV	(SP)+,R3	;RESTORE THE REGISTERS
	MOV	(SP)+,R2
	RTS	PC		;RETURN
;FLOATING POINT NUMBER TO "E" OR "F" FORMAT STRING  - "CVG"

;"CVG" - DETERMINES IF THE NUMBER IN AC0 CAN BE WRITTEN BY "CVF", IF
;IT CAN, THEN CVF IS CALLED, ELSE THE NUMBER IS PRINTED USING "CVE".

CVG:	LDF	AC0,AC1		;COPY THE  NUMBER
	CFCC			;TRANSFER THE CONDITIONAL CODES TO CPU
	ABSF	AC1		;CONVERT NUMBER TO ABSOLUTE VALUES
	BEQ	RUNF		;IF NUMBER = 0.0, EXECUTE CVF
	MOV	DIG,R1		;GET THE NUMBER OF DECIMAL DIGITS TO BE TYPED
	ASH	#2,R1		;MULT BY 4 TO USE A FLOATING POINT INDEX
	MULF	TENLST(R1),AC1	;CHECK IF NUMBER SMALLER THAN 1.0@-DIG
	CMPF	TENLST,AC1	;COMPARE TO 1.0
	CFCC			;TRANSFER CONDITIONAL CODES TO CPU
	BGT	RUNE		;IF LESS THAN 1.0@-DIG, PRINT USING CVE
	MOV	WIDTH,R1	;GET THE TOTAL NUMBER OF DIGITS TO BE PRINTED
	ASH	#2,R1		;USE THIS AS A F.P. INDEX
	NEG	R1
	MULF	TENLST(R1),AC1	;CHECK IF GREATER THAN WIDTH-DIG LONG
	CMPF	TENLST,AC1	;COMPARE TO 1.0
	CFCC			;TRANSFER CONDITIONAL CODES
	BGE	RUNF		;IF TOO LARGE, USE CVE
RUNE:	JSR	PC,CVE
	RTS	PC
RUNF:	JSR	PC,CVF
	RTS	PC
;	PRINTING ROUTINE USED BY "CVF" & "CVE"

PRTF:	TSTF	AC0		;TEST THE SIGN OF THE NUMBER
	MOVB	#40,MSIGN	;ASSUME SIGN POSITIVE
	CFCC			;TRANSFER THE CONDITIONAL CODES TO CPU
	ABSF	AC0		;CLEAR THE SIGN OF THE NUMBER
	BGE	.+10		
  	MOVB	#55,MSIGN	;IF NEGATIVE PUT IN "-" SIGN
	MODF	TEN,AC0		;COMPUTE M.S. INTEGER DIGIT
	CLR	R3		;INDICATE SIGN NOT YET WRITTEN
DIGLP:	TST	PT		;CHECK IF TIME TO PRINT DECIMAL POINT
	BNE	GETDG		;SKIP IF NOT
	TST	R3		;HAVE WE PRINTED SIGN YET?
	BNE	WTDP		;SKIP IF WE HAVE
	MOVB	MSIGN,(R0)+	;ELSE PRINT SIGN BEFORE DECIMAL POINT
	INC	R3		;INDICATE SIGN PRINTED
WTDP:	MOVB	#56,(R0)+	;PRINT DECIMAL POINT
GETDG:	STCFI	AC1,R2 		;SAVE M.S. INTEGER DIGIT
	CFCC			;CHECK FOR NUMBER TOO LARGE TO INTEGERIZE
	BCC	CHKSZ
TOLGE:	ADDF	AC1,AC0		;IF TWO LARGE, PUT IT BACK TOGETHER
	MODF	TENTH,AC0	;SCALE DOWN AND TRY INTEGERIZING AGAIN
	INC	R1		;PRINT OUT ONE MORE DIGIT
	INC	PT		;SHIFT DECIMAL POINT TO PUT IN EXTRA DIGIT
	TST	R3		;CHECK IF SIGN AND D.P. ALREADY WRITTEN
	BEQ	GETDG		;GO CHECK IF IN RANGE IF NOT WRITTEN
	CLR	R3		;CLEAR SIGN AND D.P.
	SUB	#2,R0		;ADJUST BYTE POINTER
	JMP	GETDG		;GO CHECK IF IN RANGE AGAIN
CHKSZ:	TST     R2              ;TEST INTEGER
	BLT	TOLGE		;IF TOO LARGE, GO SCALE AGAIN
	CMP	R2,#9.		;CHECK IF LESS THAN 9
	BGT	TOLGE		;SCALE IF GREATER THAN 9
      	MODF	TEN,AC0		;START COMPUTING NEXT INTEGER DIGIT
	TST	R3		;HAVE WE PRINTED SIGN YET?
	BNE	SETBS		;SKIP IF WE HAVE
	TST	R2		;CHECK IF LEADING ZERO
	BEQ	WTSP		;IF IT IS GO WRITE A SPACE CHARACTER
	MOVB	MSIGN,(R0)+	;FIRST CHARACTER, NOW PRINT SIGN
	INC	R3		;INDICATE SIGN PRINTED
SETBS:	BIS	#60,R2		;SET ASC ZERO BASE
	JMP	WTCH
WTSP:	MOVB	#40,R2		;WRITE A SPACE CHARACTER
WTCH:	MOVB	R2,(R0)+	;PUT CHARACTER IN I/O BUFFER
	DEC	PT		;DECREMENT DECIMAL POINT COUNT
	SOB	R1,DIGLP	;DONE WITH CHARACTERS?
	RTS	PC		;RETURN
;LOCAL STORAGE AREA

MSIGN:	0		;SIGN OF CURRENT NUMBER
ESIGN:	0		;SIGN OF EXPONENT
EXPON:	0
NUM:	.WORD  0,0
WIDTH:	8. 		;DEFAULT NUMBER OF CHARACTERS IN OUTPUT STRING
DIG:	3		;DEFAULT NUMBER OF DECIMAL DIGITS
OLDW:	8.		;OLD VALUES OF WIDTH AND DIG
OLDD:	3
PT:	0		;NUMBER OF DIGITS BEFORE DECIMAL POINT

;TABLE OF F.P. DIGITS FROM 0 TO 9.0

DGLST:	.FLT2	 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0

;TABLE OF POWERS OF TEN

	.WORD      531,143735,  1410, 16352,  2252, 22045,  3124,126456
	.WORD	  4004,166075,  4646, 23514,  5517,130437,  6401,147263
	.WORD	  7242, 41140, 10112,151370, 10775,103666, 11636, 72322
	.WORD	 12506, 11006, 13367,113210, 14232,137025, 15101, 66632
	.WORD	 15761,144400, 16627, 16640, 17474,162410, 20354, 17113
	.WORD	 21223,111357, 22070, 73652, 22746,112625, 23620, 16575
	.WORD	 24464, 22334, 25341, 27023, 26214,136314, 27057,165777
	.WORD	 27733,163377, 30611, 70137, 31453,146167, 32326,137625
	.WORD	 33206, 33675, 34047,142654, 34721,133427, 35603, 11157
	.WORD	 36443,153412
TENTH:	.FLT2	 0.10
TENLST:	.FLT2	 1.0
TEN:	.FLT2	 10.0
	.WORD	 41710,     0, 42572,     0, 43434, 40000, 44303, 50000
	.WORD	 45164, 22000, 46030,113200, 46676,136040, 47556, 65450
	.WORD	 50425,  1371, 51272, 41667, 52150,152245, 53021,102347
	.WORD	 53665,163041, 54543, 57651, 55416, 15712, 56261,121274
	.WORD	 57136,  5553, 60012,143443, 60655, 74354, 61530,153447
	.WORD	 62407,103170, 63251, 64026, 64123,141034, 65004, 54521
	.WORD	 65645, 67646, 66516,145617, 67401, 37472, 70241,107410
	.WORD	 71111,171312, 71774, 67574, 72635,142656, 73505, 33431
	.WORD	 74366,102337, 75232, 11414, 76100,113717, 76760,136702
	.WORD	 77626, 73231

;This is the end of the floating package.
.ENDC